JavaScript 并发集合线程安全：掌握线程安全的数据结构

随着 JavaScript 应用程序复杂性的增加，对高效且可靠的并发管理的需求变得越来越重要。 虽然 JavaScript 传统上是单线程的，但像 Node.js 和 Web 浏览器这样的现代环境通过 Web Workers 和异步操作提供了并发机制。 这引入了当多个线程或异步任务访问和修改共享数据时出现竞争条件和数据损坏的可能性。 这篇文章探讨了 JavaScript 并发集合中线程安全的挑战，并提供了构建强大且可靠应用程序的实用策略。

了解 JavaScript 中的并发

JavaScript 的事件循环启用了异步编程，允许执行操作而不会阻塞主线程。 虽然这提供了并发性，但它并没有像多线程语言中那样提供真正的并行性。 但是，Web Workers 提供了一种在单独的线程中执行 JavaScript 代码的方法，从而实现真正的并行处理。 这种能力对于计算密集型任务尤其有价值，否则会阻塞主线程，从而导致糟糕的用户体验。

Web Workers：JavaScript 对多线程的解答

Web Workers 是独立于主线程运行的后台脚本。 它们使用消息传递系统与主线程通信。 这种隔离确保 Web Worker 中的错误或长时间运行的任务不会影响主线程的响应能力。 Web Workers 非常适合图像处理、复杂计算和数据分析等任务。

异步编程和事件循环

异步操作（如网络请求和文件 I/O）由事件循环处理。 启动异步操作后，它会被传递给浏览器或 Node.js 运行时。 操作完成后，回调函数会放置在事件循环队列中。 然后，当主线程可用时，事件循环会执行回调。 这种非阻塞方法允许 JavaScript 并发处理多个操作，而不会冻结用户界面。

线程安全的挑战

线程安全是指程序即使在多个线程并发访问共享数据时也能正确执行的能力。 在单线程环境中，线程安全通常不是问题，因为在任何给定时间只能发生一个操作。 但是，当多个线程或异步任务访问和修改共享数据时，可能会发生竞争条件，从而导致不可预测且可能造成灾难性后果的结果。 当计算的结果取决于多个线程执行的不可预测的顺序时，就会出现竞争条件。

竞争条件：错误的常见来源

当多个线程并发访问和修改共享数据时，并且最终结果取决于线程执行的特定顺序时，就会发生竞争条件。 考虑一个简单的示例，其中两个线程递增一个共享计数器：

            let counter = 0;

function incrementCounter() {
  for (let i = 0; i < 100000; i++) {
    counter++;
  }
}

const worker1 = new Worker('worker.js');
const worker2 = new Worker('worker.js');

worker1.postMessage('start');
worker2.postMessage('start');

worker1.onmessage = function(event) {
  console.log('Worker 1 finished');
};

worker2.onmessage = function(event) {
  console.log('Worker 2 finished');
  console.log('Final counter value:', counter);
};

// worker.js
self.onmessage = function(event) {
  if (event.data === 'start') {
    incrementCounter();
    self.postMessage('done');
  }
};

            

              
                Copy
              
            
          

理想情况下，`counter` 的最终值应为 200000。但是，由于竞争条件，实际值通常明显较小。 这是因为两个线程都在并发地读取和写入 `counter`，并且更新可以以不可预测的方式交错，从而导致更新丢失。

数据损坏：一个严重的后果

竞争条件可能导致数据损坏，其中共享数据变得不一致或无效。 这可能会产生严重的后果，尤其是在依赖于准确数据的应用程序中，例如金融系统、医疗设备和控制系统。 数据损坏可能难以检测和调试，因为症状可能是间歇性的且不可预测。

JavaScript 中线程安全的数据结构

为了减轻竞争条件和数据损坏的风险，必须使用线程安全的数据结构和并发模式。 线程安全的数据结构旨在确保对共享数据的并发访问是同步的，并且维护数据完整性。 虽然 JavaScript 没有像其他一些语言（如 Java 的 `ConcurrentHashMap`）那样内置的线程安全数据结构，但您可以使用几种策略来实现线程安全。

原子操作

原子操作是保证作为单个不可分割的单元执行的操作。 这意味着没有其他线程可以中断原子操作的进行。 原子操作是线程安全数据结构和并发控制的基本构建块。 JavaScript 通过 `Atomics` 对象为原子操作提供有限的支持，该对象是 SharedArrayBuffer API 的一部分。

SharedArrayBuffer

`SharedArrayBuffer` 是一种数据结构，允许多个 Web Worker 访问和修改同一内存。 这使得线程之间可以有效地共享数据，但它也引入了竞争条件的可能性。 `Atomics` 对象提供了一组原子操作，可用于安全地操作 `SharedArrayBuffer` 中的数据。

Atomics API

`Atomics` API 提供了各种原子操作，包括：

• `Atomics.add(typedArray, index, value)`：以原子方式将一个值添加到类型化数组中指定索引处的元素。
• `Atomics.sub(typedArray, index, value)`：以原子方式从类型化数组中指定索引处的元素减去一个值。
• `Atomics.and(typedArray, index, value)`：以原子方式对类型化数组中指定索引处的元素执行按位 AND 运算。
• `Atomics.or(typedArray, index, value)`：以原子方式对类型化数组中指定索引处的元素执行按位 OR 运算。
• `Atomics.xor(typedArray, index, value)`：以原子方式对类型化数组中指定索引处的元素执行按位 XOR 运算。
• `Atomics.exchange(typedArray, index, value)`：以原子方式用一个新值替换类型化数组中指定索引处的元素，并返回旧值。
• `Atomics.compareExchange(typedArray, index, expectedValue, newValue)`：以原子方式将类型化数组中指定索引处的元素与预期值进行比较。 如果它们相等，则该元素将替换为一个新值。 返回原始值。
• `Atomics.load(typedArray, index)`：以原子方式加载类型化数组中指定索引处的值。
• `Atomics.store(typedArray, index, value)`：以原子方式将一个值存储在类型化数组中指定索引处。
• `Atomics.wait(typedArray, index, value, timeout)`：阻塞当前线程，直到类型化数组中指定索引处的值发生更改或超时到期。
• `Atomics.notify(typedArray, index, count)`：唤醒指定数量的线程，这些线程正在等待类型化数组中指定索引处的值。

这是一个使用 `Atomics.add` 实现线程安全计数器的示例：

            const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
const counter = new Int32Array(sab);

function incrementCounter() {
  for (let i = 0; i < 100000; i++) {
    Atomics.add(counter, 0, 1);
  }
}

const worker1 = new Worker('worker.js');
const worker2 = new Worker('worker.js');

worker1.postMessage('start');
worker2.postMessage('start');

worker1.onmessage = function(event) {
  console.log('Worker 1 finished');
};

worker2.onmessage = function(event) {
  console.log('Worker 2 finished');
  console.log('Final counter value:', Atomics.load(counter, 0));
};

// worker.js
self.onmessage = function(event) {
  if (event.data === 'start') {
    incrementCounter();
    self.postMessage('done');
  }
};

            

              
                Copy
              
            
          

在此示例中，`counter` 存储在 `SharedArrayBuffer` 中，并且 `Atomics.add` 用于以原子方式递增计数器。 这确保了 `counter` 的最终值始终为 200000，即使多个线程并发地递增它。

锁和信号量

锁和信号量是同步原语，可用于控制对共享资源的访问。 锁（也称为互斥锁）一次只允许一个线程访问共享资源，而信号量允许有限数量的线程并发访问共享资源。

使用 Atomics 实现锁

可以使用 `Atomics.compareExchange` 和 `Atomics.wait`/`Atomics.notify` 操作来实现锁。 这是一个简单的锁实现的示例：

            class Lock {
  constructor() {
    this.sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.lock = new Int32Array(this.sab);
    this.UNLOCKED = 0;
    this.LOCKED = 1;
  }

  lockAcquire() {
    while (Atomics.compareExchange(this.lock, 0, this.UNLOCKED, this.LOCKED) !== this.UNLOCKED) {
      Atomics.wait(this.lock, 0, this.LOCKED, Number.POSITIVE_INFINITY); // Wait until unlocked
    }
  }

  lockRelease() {
    Atomics.store(this.lock, 0, this.UNLOCKED);
    Atomics.notify(this.lock, 0, 1); // Wake up one waiting thread
  }
}

// Usage
const lock = new Lock();

function criticalSection() {
  lock.lockAcquire();
  try {
    // Access shared resources safely here
    console.log('Critical section entered');
    // Simulate some work
    for (let i = 0; i < 1000; i++) {}
  } finally {
    lock.lockRelease();
    console.log('Critical section exited');
  }
}

const worker1 = new Worker('worker.js');
const worker2 = new Worker('worker.js');

worker1.postMessage({ action: 'start', lockSab: lock.sab });
worker2.postMessage({ action: 'start', lockSab: lock.sab });

// worker.js
let lock;

class Lock {
  constructor(sab) {
    this.sab = sab;
    this.lock = new Int32Array(this.sab);
    this.UNLOCKED = 0;
    this.LOCKED = 1;
  }

  lockAcquire() {
    while (Atomics.compareExchange(this.lock, 0, this.UNLOCKED, this.LOCKED) !== this.UNLOCKED) {
      Atomics.wait(this.lock, 0, this.LOCKED, Number.POSITIVE_INFINITY);
    }
  }

  lockRelease() {
    Atomics.store(this.lock, 0, this.UNLOCKED);
    Atomics.notify(this.lock, 0, 1);
  }
}

self.onmessage = function(event) {
  if (event.data.action === 'start') {
    lock = new Lock(event.data.lockSab);
    for (let i = 0; i < 5; i++) {
      criticalSection();
    }
  }

  function criticalSection() {
    lock.lockAcquire();
    try {
      console.log('Worker ' + self.name + ': Critical section entered');
    } finally {
      lock.lockRelease();
      console.log('Worker ' + self.name + ': Critical section exited');
    }
  }
};

            

              
                Copy
              
            
          

此示例演示了如何使用 `Atomics` 来实现一个简单的锁，该锁可用于保护共享资源免受并发访问。 `lockAcquire` 方法尝试使用 `Atomics.compareExchange` 获取锁。 如果锁已被持有，则线程将使用 `Atomics.wait` 等待直到锁被释放。 `lockRelease` 方法通过将锁值设置为 `UNLOCKED` 并使用 `Atomics.notify` 通知等待线程来释放锁。

信号量

信号量是一种比锁更通用的同步原语。 它维护一个计数，表示可用资源的数量。 线程可以通过递减计数来获取资源，并且可以通过递增计数来释放资源。 信号量可用于控制对有限数量的共享资源的并发访问。

不变性

不变性是一种编程范例，强调创建创建后无法修改的对象。 当数据是不可变的，就没有竞争条件的风险，因为多个线程可以安全地访问数据，而不必担心数据损坏。 JavaScript 通过使用 `const` 变量和不可变数据结构来支持不变性。

不可变数据结构

像 Immutable.js 这样的库提供了不可变数据结构，例如 Lists、Maps 和 Sets。 这些数据结构被设计为高效且高性能，同时确保数据永远不会就地修改。 相反，对不可变数据结构的操作会返回具有更新数据的新实例。

            const { Map, List } = require('immutable');

let myMap = Map({ a: 1, b: 2, c: 3 });

// Modifying the map returns a new map
let updatedMap = myMap.set('b', 4);

console.log(myMap.toJS()); // { a: 1, b: 2, c: 3 }
console.log(updatedMap.toJS()); // { a: 1, b: 4, c: 3 }

let myList = List([1, 2, 3]);
let updatedList = myList.push(4);

console.log(myList.toJS()); // [ 1, 2, 3 ]
console.log(updatedList.toJS()); // [ 1, 2, 3, 4 ]

            

              
                Copy
              
            
          

使用不可变数据结构可以大大简化并发管理，因为您无需担心同步对共享数据的访问。 但是，重要的是要注意创建新的不可变对象可能会产生性能开销，尤其是对于大型数据结构。 因此，权衡不变性的好处与潜在的性能成本至关重要。

消息传递

消息传递是一种并发模式，其中线程通过相互发送消息来进行通信。 线程不是直接共享数据，而是通过消息交换信息，这些消息通常被复制或序列化。 这消除了对共享内存和同步原语的需求，从而更容易推理并发性并避免竞争条件。 JavaScript 中的 Web Workers 依赖于消息传递来实现主线程和 worker 线程之间的通信。

Web Worker 通信

如前面的示例所示，Web Workers 使用 `postMessage` 方法和 `onmessage` 事件处理程序与主线程通信。 这种消息传递机制提供了一种干净且安全的方式来在线程之间交换数据，而没有与共享内存相关的风险。 但是，重要的是要注意，消息传递可能会引入延迟和开销，因为在线程之间发送数据时需要序列化和反序列化数据。

Actor 模型

Actor 模型是一种并发模型，其中计算由 actor 执行，actor 是独立的实体，通过异步消息传递相互通信。 每个 actor 都有自己的状态，并且只能响应传入的消息来修改自己的状态。 这种状态隔离消除了对锁和其他同步原语的需求，从而更容易构建并发和分布式系统。

Actor 库

虽然 JavaScript 没有内置对 Actor 模型的支持，但一些库实现了这种模式。 这些库提供了一个框架，用于创建和管理 actor、在 actor 之间发送消息以及处理异步事件。 Actor 模型可能是构建高度并发和可扩展应用程序的强大工具，但它也需要一种不同的程序设计思维方式。

JavaScript 中线程安全的最佳实践

构建线程安全的 JavaScript 应用程序需要仔细的规划和对细节的关注。 以下是一些需要遵循的最佳实践：

• 最小化共享状态：共享状态越少，出现竞争条件的风险就越小。 尝试将状态封装在单个线程或 actor 中，并通过消息传递进行通信。
• 尽可能使用原子操作：当共享状态不可避免时，使用原子操作来确保安全地修改数据。
• 考虑不变性：不变性可以完全消除对同步原语的需求，从而更容易推理并发性。
• 谨慎使用锁和信号量：锁和信号量会引入性能开销和复杂性。 仅在必要时使用它们，并确保正确使用它们以避免死锁。
• 彻底测试：彻底测试您的并发代码，以识别和修复竞争条件和其他与并发相关的错误。 使用像并发压力测试这样的工具来模拟高负载场景并暴露潜在问题。
• 遵循编码标准：遵守编码标准和最佳实践，以提高并发代码的可读性和可维护性。
• 使用 Linters 和静态分析工具：在开发过程的早期使用 Linters 和静态分析工具来识别潜在的并发问题。

真实世界的例子

线程安全在各种真实世界的 JavaScript 应用程序中至关重要：

• Web 服务器：Node.js Web 服务器处理多个并发请求。 确保线程安全对于维护数据完整性和防止崩溃至关重要。 例如，如果服务器管理用户会话数据，则必须仔细同步对会话存储的并发访问。
• 实时应用程序：像聊天服务器和在线游戏这样的应用程序需要低延迟和高吞吐量。 线程安全对于处理并发连接和更新游戏状态至关重要。
• 数据处理：执行数据处理的应用程序，例如图像编辑或视频编码，可以从并发性中受益。 线程安全对于确保正确处理数据并且结果一致是必需的。
• 科学计算：科学应用程序通常涉及可以使用 Web Workers 并行化的复杂计算。 线程安全对于确保这些计算的结果准确至关重要。
• 金融系统：金融应用程序需要高精度和可靠性。 线程安全对于防止数据损坏和确保正确处理事务至关重要。 例如，考虑一个股票交易平台，多个用户正在并发地下订单。

结论

线程安全是构建强大且可靠的 JavaScript 应用程序的关键方面。 虽然 JavaScript 的单线程特性简化了许多并发问题，但 Web Workers 和异步编程的引入需要仔细关注同步和数据完整性。 通过了解线程安全的挑战并采用适当的并发模式和数据结构，开发人员可以构建高度并发和可扩展的应用程序，这些应用程序可以抵抗竞争条件和数据损坏。 拥抱不变性、使用原子操作以及仔细管理共享状态是掌握 JavaScript 中线程安全的关键策略。

随着 JavaScript 的不断发展并拥抱更多的并发特性，线程安全的重要性只会增加。 通过随时了解最新的技术和最佳实践，开发人员可以确保他们的应用程序在面对日益增长的复杂性时保持强大、可靠和高性能。